home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / Eudora 1.3.1 / source / nickmng.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-16  |  16.5 KB  |  594 lines  |  [TEXT/MPS ]
  1. #define FILE_NUM 2
  2. /* Copyright (c) 1990-1992 by the University of Illinois Board of Trustees */
  3. /************************************************************************
  4.  * routines to manage the nickname list
  5.  ************************************************************************/
  6. #pragma load EUDORA_LOAD
  7. #pragma segment NickMng
  8.  
  9. /************************************************************************
  10.  * The aliases list has the following structure:
  11.  * <length byte>name-of-alias<2 length bytes>expansion-of-alias...
  12.  * The aliases file contains lines of the form:
  13.  * "alias" name-of-alias expansion of alias<newline>
  14.  * Newlines may be escaped with "\".
  15.  * Lines not beginning with "alias" will be ignored
  16.  ************************************************************************/
  17.  
  18. /************************************************************************
  19.  * private functions
  20.  ************************************************************************/
  21. typedef struct
  22. {
  23.     Str31 name;
  24.     long offset;
  25. } AliasSortType, *AliasSortPtr, **AliasSortHandle;
  26.  
  27.     int ReadAliases(UHandle intoH,short cmdName);
  28.     Boolean NeatenLine(UPtr line, long *len);
  29.     short GatherCompAddresses(MyWindowPtr win,Handle biglist);
  30.     int BuildAliasInversion(AliasSortHandle *tableHP, long *count);
  31.     void AliasSortSwap(AliasSortPtr as1, AliasSortPtr as2);
  32. #define issep(c) (isspace(c) || (c)==',')
  33.  
  34. /************************************************************************
  35.  * RegenerateAliases - make sure the alias list is in memory
  36.  ************************************************************************/
  37. int RegenerateAliases(UHandle *intoH,short cmdName)
  38. {
  39.     int err=0;
  40.     
  41.     if (*intoH==nil)
  42.     {
  43.         *intoH=NuHandle(0L);
  44.         if (!*intoH) return(WarnUser(ALLO_ALIAS,MemError()));
  45.         err = ReadAliases(*intoH,cmdName);
  46.     }
  47.     else
  48.     {
  49.         HNoPurge(*intoH);
  50.         if (!**intoH)
  51.         {
  52.             ReallocHandle(*intoH,0);
  53.             if (!*intoH) return(WarnUser(ALLO_ALIAS,MemError()));
  54.             HNoPurge(*intoH);
  55.             err=ReadAliases(*intoH,cmdName);
  56.         }
  57.     }
  58.     if (err) ZapHandle(*intoH);
  59. #ifdef DEBUG
  60.     else ASSERT(GetHandleSize(*intoH));
  61. #endif
  62.     return(err);
  63. }
  64.  
  65. /************************************************************************
  66.  * ReadAliases - read the list of aliases
  67.  ************************************************************************/
  68. int ReadAliases(UHandle intoH,short cmdName)
  69. {
  70.     Str31 aliasFile;
  71.     Str31 aliasCmd;
  72.     int err;
  73.     Str255 line;
  74.     short expBytes;
  75.     UPtr spot,anchor,expSpot;
  76.     short type;
  77.     Boolean exLine=False;
  78.     long expOffset=0;
  79.     long len;
  80.     
  81.     GetRString(aliasFile,ALIAS_FILE);
  82.     GetRString(aliasCmd,cmdName);
  83.     if (err=OpenLine(MyVRef,MyDirId,aliasFile))
  84.         return(err==fnfErr ? noErr : FileSystemError(OPEN_ALIAS,aliasFile,err));
  85.     while ((type=GetLine(line,sizeof(line)))>0)
  86.     {
  87.         len = strlen(line);
  88.         if (exLine || type==LINE_MIDDLE)
  89.         {
  90.             if (expOffset)
  91.             {
  92.                 len = strlen(line);
  93.                 exLine = NeatenLine(line,&len);
  94.                 if (exLine && !issep(*line))
  95.                 {
  96.                     if (err=PtrAndHand(" ",intoH,1)) break;
  97.                     expBytes++;
  98.                 }
  99.                 if (err=PtrAndHand(line,intoH,len)) break;
  100.                 expBytes += len;
  101.             }
  102.         }
  103.         else
  104.         {
  105.             exLine = NeatenLine(line,&len);
  106.             if (expOffset)
  107.             {
  108.                 (*intoH)[expOffset] = expBytes >> 8;
  109.                 (*intoH)[expOffset+1] = expBytes & 0xff;
  110.                 expOffset = expBytes = 0;
  111.             }
  112.             if (len > *aliasCmd && !striscmp(line,aliasCmd+1))
  113.             {
  114.                 for (spot=line+*aliasCmd+1;issep(*spot);spot++);                /* skip ws */
  115.                 for (anchor=spot;*spot && !issep(*spot);spot++);                /* find name */
  116.                 for (expSpot=spot;issep(*expSpot);expSpot++);                     /* skip ws */
  117.                 if (*expSpot)                                                                                     /* valid */
  118.                 {
  119.                     anchor[-1] = MIN(MAX_NICKNAME,spot-anchor);
  120.                     if (err=PtrAndHand(anchor-1,intoH,anchor[-1]+3)) break;
  121.                     expOffset = GetHandleSize(intoH)-2;
  122.                     if (err=PtrAndHand(expSpot,intoH,len-(expSpot-line))) break;
  123.                     expBytes = len-(expSpot-line);
  124.                 }
  125.             }
  126.         }
  127.     }
  128.     CloseLine();
  129.     if (type    || err)
  130.         return(err ? WarnUser(ALLO_ALIAS,err) :
  131.                                             FileSystemError(READ_ALIAS,aliasFile,type));
  132.     if (expOffset)
  133.     {
  134.         (*intoH)[expOffset] = expBytes >> 8;
  135.         (*intoH)[expOffset+1] = expBytes & 0xff;
  136.         expOffset = 0;
  137.     }
  138.     return(noErr);
  139. } 
  140.  
  141. /************************************************************************
  142.  * NeatenLine - strip the newline from a line; if it was escaped, strip
  143.  * the backslash, and return True
  144.  ************************************************************************/
  145. Boolean NeatenLine(UPtr line, long *len)
  146. {
  147.     if (line[*len-1]=='\n') line[--*len] = 0;
  148.     if (line[*len-1]=='\\')
  149.     {
  150.         line[--*len] = 0;
  151.         return(True);
  152.     }
  153.     return(False);
  154. }
  155.  
  156.  
  157. /************************************************************************
  158.  * CountAliasTotal - how long is an alias (altogether)
  159.  ************************************************************************/
  160. long CountAliasTotal(UHandle aliases,long offset)
  161. {
  162.     return(CountAliasAlias(aliases,offset)+1+CountAliasExpansion(aliases,offset)+2);
  163. }
  164.  
  165. /************************************************************************
  166.  * CountAliasAlias - how long is the alias part of an alias (length byte
  167.  * not counted)
  168.  ************************************************************************/
  169. long CountAliasAlias(UHandle aliases,long offset)
  170. {
  171.     return ((unsigned) (*aliases)[offset]);
  172. }
  173.  
  174. /************************************************************************
  175.  * CountAliasExpansion - how long is an alias expansion (length word
  176.  * not counted)
  177.  ************************************************************************/
  178. long CountAliasExpansion(UHandle aliases,long offset)
  179. {
  180.     long base=offset+CountAliasAlias(aliases,offset)+1;
  181.     return (256*(unsigned)(*aliases)[base] + (unsigned)(*aliases)[base+1]);
  182. }
  183.  
  184.  
  185. /************************************************************************
  186.  * AddAlias - add an alias
  187.  ************************************************************************/
  188. short AddAlias(UHandle aliases,UPtr name,Handle addresses)
  189. {
  190.     long addrSize = addresses ? GetHandleSize(addresses) : 0;
  191.     long size = GetHandleSize(aliases);
  192.  
  193.     SetHandleBig(aliases,size+3+*name+addrSize);
  194.     if (MemError()) return(WarnUser(MEM_ERR,MemError()));
  195.     PCopy((*aliases)+size,name);
  196.     (*aliases)[size+*name+1] = addrSize>>8 & 0xff;
  197.     (*aliases)[size+*name+2] = addrSize & 0xff;
  198.     if (addrSize) BlockMove(*addresses,(*aliases+size+*name+3),addrSize);
  199.     return(0);
  200. }
  201.  
  202. /************************************************************************
  203.  * RemoveAlias - remove the named alias
  204.  ************************************************************************/
  205. void RemoveAlias(UHandle aliases,UPtr name)
  206. {
  207.     long oldSize=GetHandleSize(aliases);
  208.     long offset = FindAliasFor(aliases,name+1,*name);
  209.     long length;
  210.     if (offset >= 0)
  211.     {
  212.         length = CountAliasTotal(aliases,offset);
  213.         BlockMove((*aliases)+offset+length,(*aliases)+offset,
  214.                                                                                                     oldSize-offset-length);
  215.         SetHandleBig(aliases,oldSize-length);
  216.     }
  217. }
  218.  
  219. /************************************************************************
  220.  * ReplaceAlias - replace one nickname definition with another
  221.  ************************************************************************/
  222. short ReplaceAlias(UHandle aliases,UPtr oldName,UPtr newName,Handle text)
  223. {
  224.     short oldLength;
  225.     short newLength;
  226.     short eLen;
  227.     long size, newSize;
  228.     short maxAlias=GetRLong(BUFFER_SIZE)-40;
  229.     long offset= -1;
  230.     
  231.     if (oldName && *oldName) offset = FindAliasFor(aliases,oldName+1,*oldName);
  232.     if (offset<0) return(AddAlias(aliases,newName,text));
  233.     
  234.     /*
  235.      * grab the expansion
  236.      */
  237.     eLen = GetHandleSize(text);
  238.     
  239.     /*
  240.      * figure the sizes
  241.      */
  242.     oldLength = CountAliasTotal(aliases,offset);
  243.     newLength = *newName + eLen + 3;
  244.     if (newLength > maxAlias)
  245.     {
  246.         WarnUser(ALIAS_TOO_LONG, maxAlias);
  247.         eLen -= newLength-maxAlias;
  248.         newLength = maxAlias;
  249.     }
  250.             
  251.     /*
  252.      * do we need to expand?
  253.      */
  254.     if (newLength > oldLength)
  255.     {
  256.         size = GetHandleSize(aliases);
  257.         newSize = size+newLength-oldLength;
  258.         SetHandleBig(aliases,newSize);
  259.         if (MemError()) return(WarnUser(COULDNT_MOD_ALIAS,MemError()));
  260.         BlockMove((*aliases)+offset+oldLength,(*aliases)+offset+newLength,
  261.                                             size-offset-oldLength);
  262.     }
  263.  
  264.     /*
  265.      * put the bytes in
  266.      */
  267.     PCopy((*aliases)+offset,newName);
  268.     (*aliases)[offset+*newName+1] = (eLen>>8) & 0xff;
  269.     (*aliases)[offset+*newName+2] = eLen & 0xff;
  270.     BlockMove(*text,(*aliases)+offset+*newName+3,eLen);
  271.     
  272.     /*
  273.      * do we get to contract?
  274.      */
  275.     if (newLength<oldLength)
  276.     {
  277.         size = GetHandleSize(aliases);
  278.         newSize = size+newLength-oldLength;
  279.         BlockMove((*aliases)+offset+oldLength,(*aliases)+offset+newLength,
  280.                                             size-offset-oldLength);
  281.         SetHandleBig(aliases,newSize);
  282.     }
  283.     return(0);
  284. }
  285.  
  286. /************************************************************************
  287.  * MakeCompNick - make a nickname out of a comp window
  288.  ************************************************************************/
  289. void MakeCompNick(MyWindowPtr win)
  290. {
  291.     Handle biglist;
  292.     
  293.     biglist = NuHandle(0);
  294.     (void) GatherCompAddresses(win,biglist);
  295.  
  296.     /*
  297.      * and make the nickname...
  298.      */
  299.     if (**biglist) NewNick(biglist);
  300.     else WarnUser(NO_ADDRESSES,0);
  301.     
  302.     DisposeHandle(biglist);
  303. }
  304.  
  305. /************************************************************************
  306.  * GatherCompAddresses - gather the addresses from a window
  307.  ************************************************************************/
  308. short GatherCompAddresses(MyWindowPtr win,Handle biglist)
  309. {
  310.     Handle littlelist;
  311.     MessHandle messH;
  312.     static short heads[] = {TO_HEAD-1,CC_HEAD-1,BCC_HEAD-1};
  313.     short err=0;
  314.     short h;
  315.     
  316.     /*
  317.      * I vaant to suck your addresses...
  318.      */
  319.     messH = Win2MessH(win);
  320.     for (h=0;h<sizeof(heads)/sizeof(short);h++)
  321.     {
  322.         littlelist = SuckAddresses((*(*messH)->txes[heads[h]])->hText,
  323.                                                              (*(*messH)->txes[heads[h]])->teLength,True);
  324.         if (littlelist)
  325.         {
  326.           if (**littlelist)
  327.             {
  328.                 long size=GetHandleSize(biglist);
  329.                 if (size) SetHandleBig(biglist,size-1);    /* strip final terminator */
  330.                 HLock(littlelist);
  331.                 if (err=HandAndHand(littlelist,biglist)) break;
  332.             }
  333.             DisposeHandle(littlelist);
  334.         }
  335.     }
  336.     return(err);
  337. }
  338.  
  339. /************************************************************************
  340.  * MakeMessNick - make a nickname out of a message window
  341.  ************************************************************************/
  342. void MakeMessNick(MyWindowPtr win,short modifiers)
  343. {
  344.     TOCHandle out=GetOutTOC();
  345.     if (out)
  346.     {
  347.         Boolean wasDirty = (*out)->win->isDirty;
  348.         win = DoReplyMessage(win,modifiers | shiftKey,0,False);
  349.         if (!win) return;
  350.         MakeCompNick(win);
  351.         CloseMyWindow(win);
  352.         (*out)->win->isDirty = wasDirty;
  353.     }
  354. }
  355.  
  356. /************************************************************************
  357.  * MakeMboxNick - make a nickname out of the selected messages in an mbox
  358.  ************************************************************************/
  359. void MakeMboxNick(MyWindowPtr win,short modifiers)
  360. {
  361.     Handle addresses=NuHandle(0);
  362.     TOCHandle tocH = (TOCHandle)win->qWindow.refCon;
  363.     MyWindowPtr messWin,compWin;
  364.   short sumNum;
  365.     short err = 0;
  366.     Boolean isOut = (*tocH)->which==OUT;
  367.     
  368.     if (!addresses) return;
  369.     for (sumNum=0;!err && sumNum<(*tocH)->count;sumNum++)
  370.     {
  371.         if ((*tocH)->sums[sumNum].selected && ((*tocH)->sums[sumNum].messH || GetAMessage(tocH,sumNum,nil,False)))
  372.         {
  373.             messWin = (*(MessType **)(*tocH)->sums[sumNum].messH)->win;
  374.             compWin = isOut ? messWin : DoReplyMessage(messWin,modifiers,0,False);
  375.             if (compWin)
  376.             {
  377.                 err=GatherCompAddresses(compWin,addresses);
  378.                 if (compWin != messWin) CloseMyWindow(compWin);
  379.             }
  380.             if (!messWin->qWindow.visible) CloseMyWindow(messWin);
  381.         }
  382.     }
  383.     
  384.     if (!err)
  385.     {
  386.         if (**addresses) NewNick(addresses);
  387.         else WarnUser(NO_ADDRESSES,0);
  388.     }
  389.     
  390.     DisposeHandle(addresses);
  391. }
  392.  
  393. /************************************************************************
  394.  * MakeCboxNick - make a nickname out of the selected messages in Out
  395.  ************************************************************************/
  396. void MakeCboxNick(MyWindowPtr win)
  397. {
  398.     Handle addresses=NuHandle(0);
  399.     TOCHandle tocH = (TOCHandle)win->qWindow.refCon;
  400.     MyWindowPtr compWin;
  401.   short sumNum;
  402.     short err = 0;
  403.     
  404.     if (!addresses) return;
  405.     for (sumNum=0;!err && sumNum<(*tocH)->count;sumNum++)
  406.     {
  407.         if ((*tocH)->sums[sumNum].selected && 
  408.             ((*tocH)->sums[sumNum].messH || GetAMessage(tocH,sumNum,nil,False)))
  409.         {
  410.             compWin = (*(MessType **)(*tocH)->sums[sumNum].messH)->win;
  411.             if (compWin)
  412.             {
  413.                 err=GatherCompAddresses(compWin,addresses);
  414.                 if (!compWin->qWindow.visible) CloseMyWindow(compWin);
  415.             }
  416.         }
  417.     }
  418.     
  419.     if (!err)
  420.     {
  421.         if (**addresses) NewNick(addresses);
  422.         else WarnUser(NO_ADDRESSES,0);
  423.     }
  424.     
  425.     DisposeHandle(addresses);
  426. }
  427.  
  428. /************************************************************************
  429.  * FlattenListWith - make an address list one to a line
  430.  ************************************************************************/
  431. void FlattenListWith(Handle h,Byte c)
  432. {
  433.   UPtr from, to;
  434.     
  435.     from = to = *h;
  436.     while (*from)
  437.     {
  438.       while (*++from) *to++ = *from;    /* skip length byte, copy string */
  439.         from++;                                                    /* skip terminator */
  440.         *to++ = c;                                        /* and add a separator */
  441.     }
  442.     if (to > *h) to--;
  443.     SetHandleBig(h,to-*h);
  444. }
  445.  
  446. /************************************************************************
  447.  * SaveAliases - save the edited aliases (if necessary)
  448.  * returns False if the operation failed
  449.  ************************************************************************/
  450. Boolean SaveAliases(void)
  451. {
  452.     Str31 aliasFile,tmpFile;
  453.     Str31 aliasCmd;
  454.     Str63 scratch;
  455.     int err;
  456.     long max, offset;
  457.     long eLen;
  458.     long bytes;
  459.     short refN=0;
  460.     int i, count;
  461.     AliasSortHandle invers=nil;
  462.     
  463.     AliasWinGonnaSave();
  464.     GetRString(aliasFile,ALIAS_FILE);
  465.     PCopy(tmpFile,aliasFile);
  466.     GetRString(scratch,TEMP_SUFFIX);
  467.     PCat(tmpFile,scratch);
  468.     if (!Aliases || !*Aliases) {WarnUser(SAVE_ALIAS,0);goto done;}
  469.     if (RegenerateAliases(&Notes,NOTE_CMD)) goto done;
  470.     if (err=MakeResFile(tmpFile,MyVRef,MyDirId,CREATOR,MAILBOX_TYPE))
  471.         {FileSystemError(SAVE_ALIAS,tmpFile,err); goto done;}
  472.     if (err=FSHOpen(tmpFile,MyVRef,MyDirId,&refN,fsRdWrPerm))
  473.         {FileSystemError(OPEN_ALIAS,tmpFile,err); goto done;}
  474.         
  475.     max = GetHandleSize(Aliases);
  476.     if (BuildAliasInversion(&invers,&count)) count=max; /* hack */
  477.  
  478.     GetRString(aliasCmd,ALIAS_CMD);
  479.     PCatC(aliasCmd,' ');
  480.     LDRef(Aliases);
  481.     for (i=0;i<count;i++)
  482.     {
  483.         if (invers) offset = (*invers)[i].offset;
  484.         if (offset>max) break;                                         /* hack */
  485.         if (!(err = FSWriteP(refN,aliasCmd)))
  486.         {
  487.             PCopy(scratch,*Aliases+offset);
  488.             PCatC(scratch,' ');
  489.             if (!(err=FSWriteP(refN,scratch)))
  490.             {
  491.                 bytes = CountAliasExpansion(Aliases,offset);
  492.                 if (!(err = FSWrite(refN,&bytes,*Aliases+offset+*scratch+2)))
  493.                 {
  494.                     bytes = 1;
  495.                     err = FSWrite(refN,&bytes,"\n");
  496.                 }
  497.             }
  498.         }
  499.     }
  500.     if (invers) DisposHandle(invers);
  501.     UL(Aliases);
  502.     
  503.     GetRString(aliasCmd,NOTE_CMD);
  504.     PCatC(aliasCmd,' ');
  505.     LDRef(Notes);
  506.     eLen = GetHandleSize(Notes);
  507.     for (offset=0;offset<eLen;offset+=CountAliasTotal(Notes,offset))
  508.     {
  509.         if (!(err = FSWriteP(refN,aliasCmd)))
  510.         {
  511.             PCopy(scratch,*Notes+offset);
  512.             PCatC(scratch,' ');
  513.             if (!(err=FSWriteP(refN,scratch)))
  514.             {
  515.                 bytes = CountAliasExpansion(Notes,offset);
  516.                 if (!(err = FSWrite(refN,&bytes,*Notes+offset+*scratch+2)))
  517.                 {
  518.                     bytes = 1;
  519.                     err = FSWrite(refN,&bytes,"\n");
  520.                 }
  521.             }
  522.         }
  523.         if (err) {FileSystemError(SAVE_ALIAS,aliasFile,err); goto done;}
  524.     }
  525.     GetFPos(refN,&bytes);
  526.     SetEOF(refN,bytes);
  527.     AliasWinDidSave();
  528.  
  529.     /* do the deed */
  530.     if (err=HDelete(MyVRef,MyDirId,aliasFile))
  531.         {FileSystemError(SAVE_ALIAS,aliasFile,err); goto done;}
  532.     if (err=HRename(MyVRef,MyDirId,tmpFile,aliasFile))
  533.         FileSystemError(SAVE_ALIAS,aliasFile,err);
  534.  
  535. done:
  536.     if (Notes) UL(Notes);
  537.     if (Aliases) UL(Aliases);
  538.     if (refN) FSClose(refN);
  539.     return(err==noErr);
  540. }
  541.  
  542. /************************************************************************
  543.  * BuildAliasInversion - create a sort table for the aliases
  544.  ************************************************************************/
  545. int BuildAliasInversion(AliasSortHandle *tableHP, long *count)
  546. {
  547.     AliasSortHandle asH=nil;
  548.     int n=0;
  549.     int err=0;
  550.     long offset,max;
  551.     AliasSortType as;
  552.     int aLen;
  553.     
  554.     if (!(asH=NuHandle(0)))
  555.         err = MemError();
  556.     else
  557.     {
  558.         max = GetHandleSize(Aliases);
  559.         for (offset = 0; offset<max; offset += CountAliasTotal(Aliases,offset))
  560.         {
  561.             n++;
  562.             aLen = CountAliasAlias(Aliases,offset);
  563.             if (aLen >= sizeof(as.name)) aLen = sizeof(as.name)-1;
  564.             BlockMove((*Aliases)+offset,as.name,aLen+1);
  565.             as.offset = offset;
  566.             if (err=PtrAndHand(&as,asH,sizeof(as))) break;
  567.         }
  568.     }
  569.     
  570.     if (!err)
  571.     {
  572.         QuickSort(LDRef(asH),sizeof(as),0,n-1,StrCompar,AliasSortSwap);
  573.         UL(asH);
  574.         *tableHP = asH;
  575.         *count = n;
  576.     }
  577.     else
  578.         if (asH) DisposHandle(asH);
  579.     
  580.     return(err);
  581. }
  582.  
  583. /************************************************************************
  584.  * AliasSortSwap - swap two AliasSortType's
  585.  ************************************************************************/
  586. void AliasSortSwap(AliasSortPtr as1, AliasSortPtr as2)
  587. {
  588.     AliasSortType asTemp;
  589.     
  590.     asTemp = *as1;
  591.     *as1 = *as2;
  592.     *as2 = asTemp;
  593. }
  594.